home *** CD-ROM | disk | FTP | other *** search
/ Gekkan Dennou Club 147 / Gekkan Dennou Club - 2000.8 Vol. 147 (Japan).7z / Gekkan Dennou Club - 2000.8 Vol. 147 (Japan) (Track 1).bin / fdimg / —‹Œêsrc.lzh / cut.c < prev    next >
C/C++ Source or Header  |  1993-03-04  |  18KB  |  856 lines
  1. #include    "3DDEF.H"
  2. #include    "GLOBAL.H"
  3. #include    "FORWARD.H"
  4. #include    "XCODE.H"
  5.  
  6. /* 禁則処理をして切り出す */
  7. /* s1 -> s2（切り出し）+ s3（余り）s1 == s3 でもＯＫ */
  8. /* 余りの長さを返す */
  9. int
  10. cut_line(STR s1,STR s2,STR s3,int jizu)
  11. {
  12. #if 1
  13. #asm
  14.     movem.l a3-a5,-(sp)
  15.     move.l 16(sp),a4    *s1
  16.     move.l 20(sp),a3    *s2
  17.     move.l 24(sp),a5    *s3
  18.     move.l 28(sp),a0    *jizu
  19.     move.l a0,-(sp)        *push jizu
  20.     pea -3(a0)        *push jizu-3
  21.     move.l a4,-(sp)        *push s1
  22.     jsr _cut_line0
  23.     lea 12(sp),sp        *clear stack
  24.  
  25. *    i = cut_line0(s1,jizu-3,jizu);
  26.  
  27. *正確には strncpy ではない(EOSをチェックしてない)
  28.     tst d0
  29.     beq cut_line_l1
  30. *    d0 != 0 である
  31.     subq.l #1,d0
  32. ctloop1:
  33.     move.b (a4)+,(a3)+    *s2 -> s1
  34.     dbra d0,ctloop1
  35.  
  36. *    move.l d4,-(sp)        *push i
  37. *    move.l a4,-(sp)        *push s1
  38. *    move.l a3,-(sp)        *push s2
  39. *    jsr _strncpy
  40. *    strncpy(s2,s1,i);
  41.  
  42. cut_line_l1:
  43.     clr.b (a3)
  44. *    clr.b (a3,d4.l)        *s2+i <- 0
  45. *    s2[i] = EOS;
  46.  
  47.     moveq.l #-1,d0
  48. *    *strcpy だぞ、ついでに長さも数えてるぞ
  49. ctloop2:
  50.     addq.l #1,d0        *EOS も含めたバイト数をかぞえてる
  51.     move.b (a4)+,(a5)+
  52.     bne ctloop2
  53.  
  54. *    pea (a4,d4.l)        *push s1+i
  55. *    move.l a5,-(sp)        *push s3
  56. *    jsr _strcpy
  57. *    strcpy(s3,&s1[i]);
  58.  
  59.  
  60. *    move.l a5,-(sp)        *push s3
  61. *    jsr _strlen
  62.  
  63. *    return(strlen(s3));
  64.  
  65. *    addq.w #4,sp
  66.     movem.l (sp)+,a3-a5
  67.     rts
  68. #endasm
  69. #else
  70.     register int i;
  71.  
  72.     i = cut_line0(s1,jizu-3,jizu);
  73.     strncpy(s2,s1,i);
  74.     strcpy(s3,&s1[i]);
  75.     s2[i] = EOS;
  76.     return(strlen(s3));
  77. #endif
  78. }
  79.  
  80. /* 禁則処理した場合のバイト数を返す */
  81. int
  82. cut_line0(STR s1,int jizu0,int jizu)
  83. {
  84.     register int dl,i;
  85.     int i0,i00;
  86.     register UINT d0,d1;
  87.     register UBYTE c1,c2;
  88.  
  89. /* i = バイトカウンタ */
  90. /* dl = 幅 */
  91.     for(dl = i = 0;dl < jizu0;) {
  92.         if (c1 = s1[i]) {            /* EOS ではない */
  93.             if (c1 == XCODE_UP) {
  94.                 i++;
  95.                 if (!(c1 = s1[i])) {
  96.                     return(i);
  97.                 }
  98.                 i++;
  99.                 /* c1 を見て、ルビならさらに進める */
  100.                 if ((XCODE_RB10 <= c1) && (c1 <= XCODE_RB2)) {    /* ルビだ */
  101.                     i += 2;
  102.                     if (c1 == XCODE_RB2) {
  103.                         i += 2;
  104.                     }
  105.                 } else {
  106.  
  107.                 }
  108.                 continue;    /* ループトップへ */
  109.             }
  110.  
  111.             i++;dl++;
  112.             if (iskanji(c1)) {    /* 漢字の１バイト目？ */
  113.                 c2 = s1[i];
  114.                 if (!c2) {
  115.                     return(i-1);
  116.                 }
  117.                 i++;dl++;
  118.                 continue;
  119.             }
  120.             if (buff_ishan2byte(c1)) {    /* ２バイト半角文字 */
  121.                 i++;
  122.                 continue;
  123.             }
  124.             if (c1 == TAB) {    /* TAB */
  125.         /* 0-7 -> 8, 8-15 -> 16... であるが、            */
  126.         /* すでに１を足してあるので、1-8 -> 8, 9-16 -> 16...    */
  127.                 dl += CUT_GETA;
  128.                 dl += TAB_LENGTH_1;
  129.                 dl -= (dl % TAB_LENGTH);
  130.                 dl -= CUT_GETA;
  131.                 continue;
  132.             }
  133.             if (c1 == CR) {        /* 改行 */
  134.                 return(i);    /* 抜ける */
  135.             }
  136.             if (c1 < '\x20') {    /* コントロールコード */
  137.                 dl++;
  138.                 continue;
  139.             }
  140.         } else {        /* EOS である */
  141.             return(i);    /* 抜ける */
  142.         }
  143.     }
  144.  
  145.     while(1) {
  146.         i0 = i;
  147.         if (!(d0 = cut_get1(s1,&i0))) {    /* EOS である */
  148.             return(i);
  149.         }
  150.  
  151.         if (d0 == CR) {
  152.             return(i0);    /* CR も送り込む */
  153.         }
  154.         i00 = i0;
  155.         d1 = cut_get2(s1,&i00);
  156.  
  157.         switch(dl-jizu) {
  158.  
  159.         case -3:    /* 次が行末禁止の全角で、かつ、さらにその次がはみだし不可能な全角 */
  160.             if (cut_is_zen(d0) && cut_matu_kin(d0) && !cut_hami_ok(d1) && cut_is_zen(d1)) {
  161.                 return(i);    /* 抜ける */
  162.             }
  163.             break;
  164.         case -2:    /* 次が行末禁止の全角 */
  165. /*printf("%d\n",cut_is_zen(d0));*/
  166. /*printf("%d\n",cut_matu_kin(d0));getchar();*/
  167.             if (cut_is_zen(d0) && cut_matu_kin(d0)) {
  168.                 return(i);    /* 抜ける */
  169.             }
  170.                 /* 次が行末禁止の半角で、かつ、さらにその次が全角 */
  171.             if (cut_is_han(d0) && cut_matu_kin(d0) && cut_is_zen(d1)) {
  172.                 return(i);    /* 抜ける */
  173.             }
  174.                 /* 次が行末禁止の半角で、かつ、さらにその次が行末禁止の半角 */
  175.             if (cut_is_han(d0) && cut_matu_kin(d0) && cut_is_han(d1) && cut_matu_kin(d1)) {
  176.                 return(i);    /* 抜ける */
  177.             }
  178.             break;
  179.         case -1:    /* 次がはみだし不可能な全角 */
  180.             if (cut_is_zen(d0) && !cut_hami_ok(d0)) {
  181.                 return(i);    /* 抜ける */
  182.             }
  183.                 /* 次が行末禁止の半角 */
  184.             if (cut_is_han(d0) && cut_matu_kin(d0)) {
  185.                 return(i);    /* 抜ける */
  186.             }
  187.             break;
  188.         case 0:        /* 次がはみだし不可能な文字 */
  189.         case 1:
  190.         case 2:
  191.             if (!cut_hami_ok(d0)) {
  192.                 return(i);    /* 抜ける */
  193.             }
  194.             break;
  195.  
  196.         case 3:        /* 次が改行でない */
  197.             if (d0 != CR) {
  198.                 return(i);    /* 抜ける */
  199.             }
  200.             break;
  201.  
  202.         default:
  203. #if 0
  204.             if (!cut_hami_ok(d0)) {
  205.                 return(i);    /* 抜ける */
  206.             } else if ((dl-jizu) < TAB_LENGTH) {
  207.                 break;
  208.                 /* TAB があるのでここまでくる可能性がある */
  209.             }
  210. #endif
  211.             return(i);    /* 抜ける */
  212.         }
  213.         i = i0;
  214.         if (cut_is_zen(d0)) {    /* 普通の全角文字 */
  215.             dl += 2;
  216.         } else if (buff_ishan2byte(d0 >> 8)) {    /* ２バイト半角文字 */
  217.             dl++;
  218.         } else {        /* １バイト文字 */
  219.             if (d0 == TAB) {    /* TAB */
  220.         /* 0-7 -> 8, 8-15 -> 16... である */
  221.                 dl += CUT_GETA;
  222.                 dl += TAB_LENGTH;
  223.                 dl -= dl % TAB_LENGTH;
  224.                 dl -= CUT_GETA;
  225. #if 0
  226.                 if ((dl -= dl % TAB_LENGTH) >= jizu) {
  227.                     return(i);    /* 抜ける */
  228.                 }
  229. #endif
  230.             } else if (d0 < '\x20') {
  231.                 dl += 2;
  232.             } else {
  233.                 dl++;
  234.             }
  235.         }
  236.     }
  237. }
  238.  
  239. /* c をすすめる */
  240. UINT
  241. cut_get1(STR s,int *c)
  242. {
  243.     register STR wp;
  244.     register UINT d;
  245.  
  246.     wp = line_skip_xcode(&s[*c]);    /* 実体のアドレスを得る */
  247.     if (etc_char_byte_haba(wp) <= 1) {
  248.         *c = (wp+1)-s;
  249.         return(*wp);
  250.     } else {
  251.         d = *wp++;
  252.         *c = (wp+1)-s;
  253.         return(d << 8 | *wp);
  254.     }
  255. }
  256.  
  257. UINT
  258. cut_get2(STR s,int *c)
  259. {
  260.     if (*s) {
  261.         return(cut_get1(s,c));
  262.     } else {
  263.         return(0);
  264.     }
  265. }
  266.  
  267. int
  268. cut_is_zen(UINT c)
  269. {
  270.     if (c >= 0x100) {
  271.         c >>= 8;
  272.     }
  273.     return(iskanji(c));
  274. }
  275.  
  276. int
  277. cut_is_han(UINT c)
  278. {
  279.     if (c >= 0x100) {
  280.         c >>= 8;
  281.     }
  282.     return(!iskanji(c));
  283. }
  284.  
  285. /* 行末で、はみだしてもよい２バイト文字 SW 差し換え用 */
  286. UWORD byte2_hami_ok_list0[] = {
  287. L'、',L'。',L'，',L'．',L'・',L'？',L'！',L'゛',L'゜',L'´',L'｀',L'…',L'‥',
  288. L'’',L'”',L'）',L'〕',L'］',L'｝',L'〉',L'》',L'」',L'』',L'】',L'＞',
  289. L'°',L'′',L'″',
  290. L'≫'
  291. /*L'ぁ',L'ぃ',L'ぅ',L'ぇ',L'ぉ',L'っ',*/
  292. /*L'ゃ',L'ゅ',L'ょ',L'ゎ',*/
  293. /*L'ァ',L'ィ',L'ゥ',L'ェ',L'ォ',L'ッ',*/
  294. /*L'ャ',L'ュ',L'ョ',L'ヮ',L'ヵ',L'ヶ',*/,0xffff};
  295.  
  296. UBYTE byte1_hami_ok_list0[] = {
  297. '\n','!','\'',')',',','.','>','?',']','}',
  298. '｡','｣','､','･'/*'ｧ','ｨ','ｩ','ｪ','ｫ','ｬ','ｭ','ｮ','ｯ'*/,'ﾞ','ﾟ',0xff};
  299.  
  300.  
  301. /* 行末で、はみだしてもよい２バイト文字 */
  302. UWORD byte2_hami_ok_list[] = {
  303. 0x80a7,0x80a8,0x80a9,0x80aa,0x80ab,0x80ac,0x80ad,0x80ae,0x80af,
  304. L'、',L'。',L'，',L'．',L'・',L'？',L'！',L'゛',L'゜',L'´',L'｀',L'…',L'‥',
  305. L'’',L'”',L'）',L'〕',L'］',L'｝',L'〉',L'》',L'」',L'』',L'】',L'＞',
  306. L'°',L'′',L'″',
  307. L'≫',
  308. L'ぁ',L'ぃ',L'ぅ',L'ぇ',L'ぉ',L'っ',
  309. L'ゃ',L'ゅ',L'ょ',L'ゎ',
  310. L'ァ',L'ィ',L'ゥ',L'ェ',L'ォ',L'ッ',
  311. L'ャ',L'ュ',L'ョ',L'ヮ',L'ヵ',L'ヶ',0xffff};
  312.  
  313. UBYTE byte1_hami_ok_list[] = {
  314. '\n','!','\'',')',',','.','>','?',']','}',
  315. '｡','｣','､','･','ｧ','ｨ','ｩ','ｪ','ｫ','ｬ','ｭ','ｮ','ｯ','ﾞ','ﾟ',0xff};
  316.  
  317. UWORD byte2_matu_kin_list[] = {
  318. L'‘',L'“',L'（',L'〔',L'［',L'｛',L'〈',L'《',L'「',L'『',L'【',L'＜',L'≪',0xffff};
  319.  
  320. UBYTE byte1_matu_kin_list[] = {
  321. '(','<','[','{','｢',0xff};
  322.  
  323. void
  324. cut_switch_change()
  325. {
  326.     register int i;
  327.  
  328.     i = 0;
  329.     while((byte2_hami_ok_list[i] = byte2_hami_ok_list0[i]) != 0xffff) {
  330.         i++;
  331.     }
  332.     i = 0;
  333.     while((byte1_hami_ok_list[i] =byte1_hami_ok_list0[i]) != 0xff) {
  334.         i++;
  335.     }
  336. }
  337.  
  338. int
  339. cut_hami_ok(UINT c)
  340. {
  341.     if (string_1or2_byte_code(c)-1) {
  342.         register UWORD *p = byte2_hami_ok_list;
  343.  
  344.         for(;*p <= c;p++) {
  345.             if (*p == c) return(1);
  346.         }
  347.         return(0);
  348.     } else {
  349.         register UBYTE *p = byte1_hami_ok_list;
  350.  
  351.         for(;*p <= c;p++) {
  352.             if (*p == c) return(1);
  353.         }
  354.         return(0);
  355.     }
  356. }
  357.  
  358. int
  359. cut_matu_kin(UINT c)
  360. {
  361. /*printf("%x\n",c);getchar();*/
  362. /*printf("%x\n",string_1or2_byte_code(c));getchar();*/
  363.     if (string_1or2_byte_code(c)-1) {
  364.         register UWORD *p = byte2_matu_kin_list;
  365.         for(;*p <= c;p++) {
  366. /*printf("%x\n",*p);*/
  367.             if (*p == c) return(1);
  368.         }
  369.         return(0);
  370.     } else {
  371.         register UBYTE *p = byte1_matu_kin_list;
  372.         for(;*p <= c;p++) {
  373. /*printf("%x\n",*p);*/
  374.             if (*p == c) return(1);
  375.         }
  376.         return(0);
  377.     }
  378. }
  379.  
  380. /* 禁則処理をして切り出す */
  381. /* s0 + s00 -> s2（切り出し）+ s3（余り）s0 == s30 でもＯＫ */
  382. /* 返り値：-1 = s00 から s0 へ前送りがあった（s0 < s2） */
  383. /*        0 = 前送りも後送りも無かった（s0 == s2） */
  384. /*        1 = s0 から s00 へ後送りがあった（s0 > s2） */
  385. int
  386. cut_2line_link_check(STR s0,STR s00,STR s2,STR s3,int jizu)
  387. {
  388.     UBYTE s1[VERY_LONG_LINE*8];
  389.     int s0l,s00l;
  390.  
  391.     s0l = strlen(s0);
  392.     s00l = strlen(s00);
  393.     strcpy(s1,s0);
  394.     strcat(s1,s00);
  395.     cut_line(s1,s2,s3,jizu);
  396.  
  397.     if (s00l) {
  398.         return(s0l - strlen(s2));
  399.     } else {
  400.         if (s0l == strlen(s2)) {
  401.             if (etc_last(s2) == CR) {
  402.                 return(0);
  403.             } else {
  404.                 return(-1);
  405.             }
  406.         } else {
  407.             return(1);
  408.         }
  409.     }
  410. }
  411.  
  412. /* ゲタなしで */
  413. /* 文字列を表現型に変換する */
  414. /* 表示した時の半角スペース数 */
  415. void
  416. cut_disp_convert(STR s,STR dd,int jj)
  417. {
  418. #asm
  419.  
  420. XCODE_UP    equ    $0ff    * 拡張コードの開始
  421.  
  422. XCODE_MARK    equ    $020    * マーク 0x20 - 0x29
  423. XCODE_SYSMARK    equ    $030    * システムマーク 0x30 - 0x3f
  424. XCODE_MARKLAST    equ    $03f    * マークの最後
  425.  
  426. XCODE_UL    equ    $040    * 下線
  427.  
  428. XCODE_RB10    equ    $050    * 予約：１文字真ん中ルビ
  429. XCODE_RB1    equ    $051    * １文字ルビ（半角用）
  430. XCODE_RB1L    equ    $052    * １文字ルビ左（全角用）
  431. XCODE_RB1R    equ    $053    * １文字ルビ右（全角用）
  432. XCODE_RB2    equ    $054    * ２文字ルビ（全角用）
  433.  
  434.     movem.l    d1-d5/a0-a1,sdl_save
  435.     move.l _CUT_GETA,d0
  436. * d0 returns disp length
  437.     move.w _TAB_VIEW,d3
  438. * TAB FLAG
  439.     move.l 4(sp),a0
  440. * a0 = pointer to string
  441.     move.l 8(sp),a1
  442. * a1 = pointer to store
  443.     move.l 12(sp),d5
  444. * d5 = jizume
  445.  
  446. USERL16:
  447.     move.b (a0)+,d1    * 1 byte move
  448.     bmi USERL40    * 2 byte code check
  449.     beq USERL30    * eof then return
  450.  
  451.     addq.l    #1,d0    * anyway add 1(XCODE ではないから)
  452.     cmp.b #$20,d1    * control code ?
  453.     blt USERL16_1    * normal 1 byte code($20 - $7f)
  454.     move.b d1,(a1)+
  455.     bra USERL16
  456.  
  457. USERL16_1:
  458.     cmp.b #'I'-'@',d1    * TAB
  459.     bne USERL17
  460.  
  461. *0-7 -> 8, 8-15 -> 16...
  462. *already add 1 then 1-8 -> 8, 9-16 -> 16...
  463.     move.l d0,d4
  464.     * TAB 処理用に保存
  465.     add.w _TAB_LENGTH_1,d0
  466. * d0 から d0 mod TAB_LENGTH を引く
  467.     move.l d0,d2    * コピー
  468.     divu.w _TAB_LENGTH,d2
  469.     swap d2
  470.     sub.w d2,d0
  471. * d0 OK
  472.     move.l d0,d2
  473.     sub.l d4,d2
  474. * d2+1 が進んだ桁数
  475.     tst.w d3
  476.     bne USERL_TAB_VIEW
  477.  
  478. * 見えないタブ
  479. U_T_LOOP1:
  480.     move.b #' ',(a1)+
  481.     dbra d2,U_T_LOOP1
  482.  
  483.     cmp.w d0,d5
  484. * TAB 処理中に字詰めを越えたか？
  485.     bgt USERL16    * 達してない
  486.     move.l d0,d1    * d1 = WORK
  487.     sub.w d5,d1
  488.     suba.w d1,a1
  489.     move.b #0,(a1)
  490.     move.l d5,d0
  491.  
  492.     bra USERL16
  493.  
  494. USERL_TAB_VIEW:
  495. * 見えるタブ
  496.     move.b #$80,(a1)+
  497.     move.b #$1c,(a1)+
  498. * 半角右矢印
  499.     subq.l #1,d2
  500.     blt USERL16
  501. U_T_LOOP2:
  502.     move.b #$80,(a1)+
  503.     move.b #$a5,(a1)+
  504.     * 半角中グロ
  505.     dbra d2,U_T_LOOP2
  506.  
  507.     cmp.w d0,d5
  508. * TAB 処理中に字詰めを越えたか？
  509.     bgt USERL16    * 達してない
  510.     move.l d0,d1    * d1 = WORK
  511.     sub.w d5,d1
  512.     add.l d1,d1
  513.         * d1 を２倍にする
  514.     suba.w d1,a1
  515.     move.b #0,(a1) 
  516.     move.l d5,d0
  517.  
  518.     bra USERL16
  519.  
  520. USERL17
  521.     cmp.b #'J'-'@',d1    * CR
  522.     bne USERL18
  523.  
  524. *    addq.l #1,d0    * CR is 2 disp_length
  525.     move.b _KAIGYOU_HIGH,(a1)+
  526.     move.b _KAIGYOU_LOW,(a1)+
  527.     bra USERL30    * finish
  528.  
  529. USERL18
  530.     addq.l #1,d0    * control code is 2 disp_length
  531.     move.b #'^',(a1)+
  532.     add.b #'@',d1
  533.     move.b d1,(a1)+    * '^?' を転送
  534.     bra USERL16
  535.  
  536. USERL40:        * 2 byte code check
  537.     cmp.b #$ff,d1    * xcode ?
  538.     bne USERL405    * not xcode
  539.  
  540.     move.b (a0)+,d1    * get next byte
  541.     cmp.b #XCODE_UL,d1    * 2 byte xcode ?
  542.     ble USERL16    * loop again
  543.     cmp.b #XCODE_RB1R,d1    * ....
  544.     bgt USERL403
  545.     addq.l #2,a0    * 1 char RUBI
  546.     bra USERL16
  547. USERL403:        * 2 char RUBI
  548.     addq.l #4,a0
  549.     bra USERL16
  550.  
  551. USERL405:        * not xcode
  552.     move.b d1,(a1)+    * 実体は必ずある
  553.     addq.l #1,d0    * anyway add 1
  554.     cmp.b #$a0,d1
  555.     blt USERL41    * $a0 未満である
  556.  
  557.     cmp.b #$e0,d1
  558.     blt USERL16    * normal katakana -> next
  559.  
  560.     move.b (a0)+,(a1)+    * next byte move
  561.     beq USERL30    * funny byte but end
  562.     cmp.b #$f0,d1    * 1/4 kaku ?
  563.     bge USERL16
  564.     addq.l #1,d0    * normal zenkaku(block 2)
  565.     bra USERL16
  566.  
  567. USERL41:
  568.     move.b (a0)+,(a1)+    * next byte move
  569.     beq USERL30
  570.     cmp.b #$80,d1    * hankaku hiragana ?
  571.     beq USERL16
  572.     addq.l #1,d0    * normal zenkaku(block 1)
  573.     bra USERL16
  574. USERL30:
  575.     move.b #0,(a1)    * set eof
  576.     movem.l    sdl_save,d1-d5/a0-a1
  577.     rts
  578.     .data
  579.     .even
  580. sdl_save
  581.     ds.l    7
  582.  
  583. #endasm
  584. }
  585.  
  586. #if 0
  587. /* ゲタなしで */
  588. /* 文字列を表現型に変換する */
  589. void
  590. cut_disp_convert(STR s,STR dd,int jj)
  591. {
  592.     int d00 = - CUT_GETA;    /* TAB 処理のために覚えておく */
  593.     register UBYTE c;
  594.     register int ll = 0;
  595.  
  596.     while(1) {
  597.         if ((c = *s++) >= (UBYTE)'\x20') {
  598.             if (isprkana(c)) {    /* 普通の１バイトコード */
  599.                 *dd++ = c;
  600.                 ll++;
  601.             } else {        /* ２バイトコード：もしくは拡張 */
  602.                 if (c == XCODE_UP) {
  603.                     switch(*s++) {
  604.                     case XCODE_MARK+0:
  605.                     case XCODE_MARK+1:
  606.                     case XCODE_MARK+2:
  607.                     case XCODE_MARK+3:
  608.                     case XCODE_MARK+4:
  609.                     case XCODE_MARK+5:
  610.                     case XCODE_MARK+6:
  611.                     case XCODE_MARK+7:
  612.                     case XCODE_MARK+8:
  613.                     case XCODE_MARK+9:    /* マーク 0x20 - 0x29 */
  614.                     case XCODE_MARK+10:
  615.                     case XCODE_MARK+11:
  616.                     case XCODE_MARK+12:
  617.                     case XCODE_MARK+13:
  618.                     case XCODE_MARK+14:
  619.                     case XCODE_MARK+15:
  620.     
  621.                     case XCODE_SYSMARK+0:    /* システムマーク */
  622.                     case XCODE_SYSMARK+1:
  623.                     case XCODE_SYSMARK+2:
  624.                     case XCODE_SYSMARK+3:
  625.                     case XCODE_SYSMARK+4:
  626.                     case XCODE_SYSMARK+5:
  627.                     case XCODE_SYSMARK+6:
  628.                     case XCODE_SYSMARK+7:
  629.                     case XCODE_SYSMARK+8:
  630.                     case XCODE_SYSMARK+9:
  631.                     case XCODE_SYSMARK+10:
  632.                     case XCODE_SYSMARK+11:
  633.                     case XCODE_SYSMARK+12:
  634.                     case XCODE_SYSMARK+13:
  635.                     case XCODE_SYSMARK+14:
  636.                     case XCODE_SYSMARK+15:
  637.     
  638.                         break;
  639.                     case XCODE_UL:        /* 下線 */
  640.                         break;
  641.     
  642.                     case XCODE_RB10:    /* 予約：１文字真ん中ルビ */
  643.                     case XCODE_RB1:        /* １文字ルビ */
  644.                     case XCODE_RB1L:    /* １文字ルビ左（全角用） */
  645.                     case XCODE_RB1R:    /* １文字ルビ右（全角用） */
  646.                         s += 2;        /* ルビであるから、２バイト文字 */
  647.                         break;
  648.                     case XCODE_RB2:        /* ２文字ルビ（全角用） */
  649.                         s += 4;        /* ルビであるから、２バイト文字 */
  650.                     }
  651.                 } else {    /* ２バイトコードである */
  652.                     *dd++ = c;
  653.                     *dd++ = *s++;
  654.                 }
  655.             }
  656.             continue;
  657.         }
  658.         if (c) {
  659.             if (c == TAB) {    /* TAB */
  660.                 /* 0-7 -> 8, 8-15 -> 16    */
  661.                 if (TAB_VIEW) {
  662.                     *d++ = (UBYTE) '\x80';
  663.                     *d++ = (UBYTE) '\x1c';    /* 半角右矢印 */
  664.                     while(((d-d0)%TAB_LENGTH) && ((d-d0)<CURRENT_JIZUME)) {
  665.                         *d++ = (UBYTE) '\x80';
  666.                         *d++ = (UBYTE) '\xa5';    /* 半角中グロ */
  667.                     }
  668.                 } else {
  669.                     do {
  670.                         *d++ = (UBYTE) '\x20';
  671.                     } while(((d-d0)%TAB_LENGTH) && ((d-d0)<CURRENT_JIZUME));
  672.                 }
  673.             } else if (c == CR) {    /* 改行 */
  674.                 *d++ = KAIGYOU_HIGH;
  675.                 *d++ = KAIGYOU_LOW;
  676.                 *d++ = EOS;
  677.                 break;
  678.             } else {        /* 普通のコントロールコード */
  679.                 *d++ = '^';
  680.                 *d++ = c + '@';
  681.             }
  682.         } else {
  683.             *d = EOS;
  684.             break;        /* EOS で終わり */
  685.         }
  686.     }
  687. }
  688. #endif
  689.  
  690. int
  691. cut_ul_convert(STR s,STR d,int jj)
  692. {
  693.     register UBYTE c;
  694.     register int l,i;
  695.     int flag;
  696.     STR d00;
  697.  
  698.     flag = 0;
  699.     *d = EOS;
  700.     d00 = d;
  701.     while(*s) {
  702.         if (*s == XCODE_UP) {
  703.             s++;
  704.             if ((c = *s++) == XCODE_UL) {        /* 下線 */
  705.                 register STR d0,s0;
  706.  
  707.                 flag = 1;
  708.                 s0 = s;
  709.                 s = line_skip_xcode(s);    /* もしもあるとしたら属性を越える */
  710.                 c = *s;            /* 実体だ */
  711.                 s += 1 + !(etc_check_char_kind_1byte(c) & 0b000010011);
  712.                 if (c == TAB) {        /* TAB:0-7 -> 8, 8-15 -> 16 */
  713.                     d0 = d;
  714.                     d0 += TAB_LENGTH;
  715.                     d0 -= (d0 - d00) % TAB_LENGTH;
  716.                     l = d0 - d;
  717.                 } else {
  718.                     l = etc_char_disp_len(c);    /* 幅を得る */
  719.                 }
  720.                 for(i=0;i<l;i++) {
  721.                     *d++ = '~';
  722.                 }
  723.             } else {    /* XCODE だが下線ではない */
  724.                 switch(c) {
  725.                 case XCODE_RB10:    /* 予約：１文字真ん中ルビ */
  726.                 case XCODE_RB1:        /* １文字ルビ */
  727.                 case XCODE_RB1L:    /* １文字ルビ左（全角用） */
  728.                 case XCODE_RB1R:    /* １文字ルビ右（全角用） */
  729.                     s += 2;        /* ルビであるから、２バイト文字 */
  730.                     break;
  731.                 case XCODE_RB2:        /* ２文字ルビ（全角用） */
  732.                     s += 4;        /* ルビであるから、２バイト文字 */
  733.                     break;
  734.                 }
  735.             }
  736.         } else {        /* XCODE ではない */
  737.             if ((c = *s) == CR) {
  738.                 break;
  739.             }
  740.                 /* 実体だ */
  741.             s += 1 + !(etc_check_char_kind_1byte(c) & 0b000010011);
  742.             if (c == TAB) {
  743.                 *d++ = c;
  744.             } else {
  745.                 l = etc_char_disp_len(c);    /* 幅を得る */
  746.                 *d++ = ' ';
  747.                 if (l > 1) {
  748.                     *d++ = ' ';
  749.                 }
  750.             }
  751.         }
  752.     }
  753.     *d = EOS;
  754.     if (flag) {
  755.         register STR p;
  756.  
  757.         p = d+strlen(d)-1;
  758.         while(*p == ' ') {
  759.             *p-- = EOS;
  760.         }
  761.     }
  762.     return(flag);
  763. }
  764.  
  765. int
  766. cut_rubi_convert(STR s,STR d,int jj)
  767. {
  768.     register UBYTE c;
  769.     int flag,rubi_done_flag;
  770.  
  771.     rubi_done_flag = flag = 0;
  772.     *d = EOS;
  773.     while(*s) {
  774.         if (*s == XCODE_UP) {
  775.             s++;
  776.  
  777.             switch (c = *s++) {
  778.             case XCODE_RB10:    /* 予約：１文字真ん中ルビ */
  779.             case XCODE_RB1L:    /* １文字ルビ左（全角用） */
  780.             *d++ = cut_rubi_convert_to_low(*s++);
  781.             *d++ = *s++;
  782.             *d++ = ' ';
  783.             break;
  784.  
  785.             case XCODE_RB1:        /* １文字ルビ */
  786.             *d++ = cut_rubi_convert_to_low(*s++);
  787.             *d++ = *s++;
  788.             break;
  789.  
  790.             case XCODE_RB1R:    /* １文字ルビ右（全角用） */
  791.             *d++ = ' ';
  792.             *d++ = cut_rubi_convert_to_low(*s++);
  793.             *d++ = *s++;
  794.             break;
  795.  
  796.             case XCODE_RB2:        /* ２文字ルビ（全角用） */
  797.             *d++ = cut_rubi_convert_to_low(*s++);
  798.             *d++ = *s++;
  799.             *d++ = cut_rubi_convert_to_low(*s++);
  800.             *d++ = *s++;
  801.             break;
  802.  
  803.             default:    /* ,,, */
  804.             continue;
  805.             break;
  806.             }
  807.             flag = rubi_done_flag = 1;
  808.             if ((c = *s) == XCODE_UP) {
  809.                 continue;
  810.             }
  811.         } else {            /* XCODE ではない */
  812.             if ((c = *s) == CR) {
  813.                 break;
  814.             }
  815.                 /* 実体だ */
  816.             s += 1 + !(etc_check_char_kind_1byte(c) & 0b000010011);/* １バイト物か？ */
  817.             if (rubi_done_flag) {    /* 既に d は送ってある */
  818.                 rubi_done_flag = 0;
  819.                 continue;
  820.             }
  821.             if (c == TAB) {
  822.                 *d++ = c;
  823.             } else {
  824.                 register int l;
  825.  
  826.                 l = etc_char_disp_len(c);    /* 幅を得る */
  827.                 *d++ = ' ';
  828.                 if (l > 1) {
  829.                     *d++ = ' ';
  830.                 }
  831.             }
  832.         }
  833.     }
  834.     *d = EOS;
  835.     if (flag) {
  836.         register STR p;
  837.  
  838.         p = d+strlen(d)-1;
  839.         while(*p == ' ') {
  840.             *p-- = EOS;    /* 後ろから削る */
  841.         }
  842.     }
  843.     return(flag);
  844. }
  845.  
  846. UBYTE
  847. cut_rubi_convert_to_low(UBYTE c)
  848. {
  849.     if (c == 0xf0) {
  850.         return(0xf2);
  851.     } else if (c == 0xf1) {
  852.         return(0xf3);
  853.     }
  854.     return(c);
  855. }
  856.